home *** CD-ROM | disk | FTP | other *** search
/ Revolution - Das Atari CD Magazin 1997 / Revolution - Das Atari CD Magazin 1.iso / software / anwendng / utility / cbhd502 / src / c / scsiio.c < prev    next >
C/C++ Source or Header  |  1997-01-21  |  5KB  |  237 lines
  1. /*{{{}}}*/
  2. /****************************************************************************
  3.  *
  4.  * Definitionen für SCSI-Calls in C
  5.  *
  6.  * $Source: u:\k\usr\src\scsi\cbhd\rcs\scsiio.c,v $
  7.  *
  8.  * $Revision: 1.6 $
  9.  *
  10.  * $Author: Steffen_Engel $
  11.  *
  12.  * $Date: 1996/02/14 11:29:58 $
  13.  *
  14.  * $State: Exp $
  15.  *
  16.  *****************************************************************************
  17.  * History:
  18.  *
  19.  * $Log: scsiio.c,v $
  20.  * Revision 1.6  1996/02/14  11:29:58  Steffen_Engel
  21.  * Diverser Kleinkram
  22.  *
  23.  * Revision 1.5  1995/11/28  19:14:14  S_Engel
  24.  * *** empty log message ***
  25.  *
  26.  * Revision 1.4  1995/10/22  15:42:28  S_Engel
  27.  * Anpassung auf lange Handles
  28.  *
  29.  * Revision 1.3  1995/10/03  12:55:34  S_Engel
  30.  * Textklappungen, Initialisierung nur maximal einmal
  31.  *
  32.  * Revision 1.2  1995/09/29  09:14:30  S_Engel
  33.  * virtuelles RAM wird berücksichtigt
  34.  *
  35.  * Revision 1.1  1995/06/16  12:06:46  S_Engel
  36.  * Initial revision
  37.  *
  38.  *
  39.  *
  40.  ****************************************************************************/
  41.  
  42. #include <import.h>
  43.  
  44. #ifdef __PUREC__
  45.   #include <tos.h>
  46. #endif
  47.  
  48. #ifdef _GCC_
  49.   #include <string.h>
  50.   #include <osbind.h>
  51. #endif
  52.  
  53. #include "cookie.h"
  54.  
  55. #include <export.h>
  56. #include <scsidrv/scsiio.h>
  57.  
  58. char *VirtBuffer;
  59.  
  60. /* nach den SCSI-Cookie suchen */
  61. void srch_cookie(void)
  62. {{{
  63.  
  64.   COOKIE *cookie;
  65.  
  66.   cookie = getcookie((ULONG)0x53435349);          /* SCSI */
  67. /*cookie = NULL;*/
  68.  
  69.   if (cookie != NULL)
  70.   {
  71.     scsicall = (tpScsiCall) cookie->val;
  72.     if (scsicall->Version != SCSIRevision)
  73.       scsicall = NULL;
  74.   }
  75.  
  76.   cookie = getcookie((ULONG)0x504d4d55);          /* PMMU */
  77.   HasVirtual = (cookie != NULL) && (cookie->val != 0L);
  78.  
  79. }}}
  80.  
  81.  
  82. /* In und Out erst über eigene Prozeduren, wegen virtuellem RAM */
  83. LONG cdecl In(tpSCSICmd Parms)
  84. {{{
  85.   void  *oldbuf;
  86.   ULONG *phystop = (ULONG *)0x42e;
  87.   LONG  ret;
  88.  
  89.   if (scsicall == NULL)
  90.     return -1L;
  91.  
  92.  
  93.   if (HasVirtual && ((ULONG)Parms->Buffer > *phystop))
  94.   {
  95.     oldbuf = Parms->Buffer;
  96.     Parms->Buffer = VirtBuffer;
  97.  
  98.     /* jetzt den Transfer */
  99.     ret = (scsicall->In(Parms));
  100.  
  101.     /* Daten kopieren */
  102.     memcpy(oldbuf, Parms->Buffer, Parms->TransferLen);
  103.  
  104.     /* und Ergebnis melden */
  105.     return ret;
  106.   }
  107.   else
  108.   {
  109.     return (scsicall->In(Parms));
  110.   }
  111. }}}
  112.  
  113. LONG cdecl Out(tpSCSICmd Parms)
  114. {{{
  115.   ULONG *phystop = (ULONG *)0x42e;
  116.  
  117.   if (scsicall == NULL)
  118.     return -1L;
  119.  
  120.   if (HasVirtual && ((ULONG)Parms->Buffer > *phystop))
  121.   {
  122.  
  123.     /* Daten kopieren */
  124.     memcpy(VirtBuffer, Parms->Buffer, Parms->TransferLen);
  125.  
  126.     /* und neue Quelladresse eintragen */
  127.     Parms->Buffer = VirtBuffer;
  128.  
  129.   }
  130.  
  131.   return (scsicall->Out(Parms));
  132. }}}
  133.  
  134. LONG cdecl InquireSCSI (WORD          what,
  135.                         tBusInfo     *Info)
  136. {{{
  137.   if (scsicall != NULL)
  138.     return (scsicall->InquireSCSI(what, Info));
  139.   else
  140.     return -1L;
  141. }}}
  142.  
  143. LONG cdecl InquireBus  (WORD          what,
  144.                         WORD          BusNo,
  145.                         tDevInfo     *Dev)
  146. {{{
  147.   if (scsicall != NULL)
  148.     return (scsicall->InquireBus(what, BusNo, Dev));
  149.   else
  150.     return -1L;
  151. }}}
  152.  
  153. LONG cdecl CheckDev    (WORD          BusNo,
  154.                         const DLONG  *DevNo,
  155.                         char         *Name,
  156.                         UWORD        *Features)
  157. {{{
  158.   if (scsicall != NULL)
  159.     return (scsicall->CheckDev(BusNo, DevNo, Name, Features));
  160.   else
  161.     return -1;
  162.  
  163. }}}
  164.  
  165. LONG cdecl RescanBus   (WORD          BusNo)
  166. {{{
  167.   if (scsicall != NULL)
  168.     return (scsicall->RescanBus(BusNo));
  169.   else
  170.     return -1L;
  171. }}}
  172.  
  173. LONG cdecl Open        (WORD          bus,
  174.                         const DLONG  *Id,
  175.                         ULONG        *MaxLen)
  176. {{{
  177.   if (scsicall != NULL)
  178.     return (scsicall->Open(bus, Id, MaxLen));
  179.   else
  180.     return -1;
  181. }}}
  182.  
  183.  
  184. LONG cdecl Close       (tHandle       handle)
  185. {{{
  186.   if (scsicall != NULL)
  187.     return (scsicall->Close(handle));
  188.   else
  189.     return -1;
  190. }}}
  191.  
  192.  
  193. LONG cdecl Error       (tHandle       handle,
  194.                         WORD          rwflag,
  195.                         WORD          ErrNo)
  196. {{{
  197.   if (scsicall != NULL)
  198.     return (scsicall->Error(handle, rwflag, ErrNo));
  199.   else
  200.     return -1L;
  201. }}}
  202.  
  203. BOOLEAN isinit = FALSE;
  204.  
  205. BOOLEAN init_scsiio()
  206. {{{
  207.   if (!isinit)
  208.   {
  209.     isinit      = TRUE;
  210.     scsicall    = NULL;
  211.     VirtBuffer  = NULL;
  212.  
  213.     srch_cookie();
  214.  
  215.     if (HasVirtual)
  216.     {
  217.       /* bei virtuellem RAM müssen wir jetzt einen Puffer im ST-RAM allozieren */
  218.       VirtBuffer = (char *)Mxalloc(64L*1024L, 0); /* 64 kB im ST-RAM */
  219.       if ((LONG)VirtBuffer <= 0)
  220.         {
  221.           if (VirtBuffer == NULL)
  222.           {
  223.             /* ohne Puffer läuft hier nix */
  224.             return FALSE;
  225.           }
  226.           else
  227.           {
  228.             VirtBuffer = NULL;
  229.           }
  230.         }
  231.     }
  232.  
  233.   }
  234.   return (scsicall != NULL);
  235. }}}
  236.         
  237.